package com.stone.java8;

import android.app.Activity;
import android.os.Bundle;
import android.support.annotation.Nullable;

import java.util.Arrays;
import java.util.Calendar;

/**
 * desc   : 3种方法引用形式 除构造方法引用形式
 * author : stone
 * email  : aa86799@163.com
 * time   : 13/03/2017 10 27
 */
public class MethodReferenceActivity extends Activity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        methodReference();
    }

    void methodReference() {//方法引用
        String num = "122";
        /*
        原本要传入一个接口 ToIntFunc ，它是一个单一抽象方法的接口，就能lambda表示
         */
//        int parse = parse((value -> Integer.parseInt(value)), num);
        /*
        ToIntFunc接口的单一方法，返回int值
        就可以使用如下 形式， 来 代替lambda  或说  代替  匿名接口声明
        该形式的特点是， 类名::方法名
         */
//        int parseValue = parse(Integer::parseInt, num);
//        int parseValue = parse((value -> parz(value)), num);
        int parseValue = parse(MethodReferenceActivity::parz, num);
        System.out.println("哈1哈" + parseValue);

        parse((value -> 18), num); //匹配 ToIntFunc
        parse((v1, v2) -> 18);// 匹配 ToIntFunc2


        Person[] persons = new Person[10];
        for (int i = 0; i < persons.length; i++) {
            Person p = new Person();
            p.name = "" + i;
            p.birthday = Calendar.getInstance().getTimeInMillis() + i;
            persons[i] = p;
        }

        //使用lambda表达式
        Arrays.sort(persons, ((o1, o2) -> o1.birthday.compareTo(o2.birthday)));
        //使用lambda表达式和类的静态方法
        Arrays.sort(persons, ((o1, o2) -> Person.compareByAge(o1, o2)));
        //使用方法引用    引用的是类的静态方法
        Arrays.sort(persons, Person::compareByAge);

//        引用的是对象的实例方法
        Arrays.sort(persons, this::compareByAge);
        Arrays.sort(persons, this::compareByName);

        String[] stringsArray = {"zello", "World"};
//        引用的是类型对象的实例方法
//        Arrays.sort(stringsArray, (o1, o2) -> o1.compareTo(o2));
        Arrays.sort(stringsArray, String::compareToIgnoreCase);//虽然只有一个参数，但内部是以一个String对象来操作的  也可以用
        System.out.println(Arrays.toString(stringsArray));


    }

    static int parz(String str) {
        return Integer.parseInt(str);
    }

    public static int parse(ToIntFunc<String> f, String num) {
        return f.applyAsInt(num);
    }

    public static int parse(ToIntFunc2<String> f) {
        return f.applyAsInt("1", "2");
    }

    public interface ToIntFunc<T> {
        int applyAsInt(T value);
    }

    public interface ToIntFunc2<T> {
        int applyAsInt(T v1, T v2);
    }

    private String get() {
        return "STONE".toLowerCase();
    }

    static class Person {


        public Person() {

        }

        public Person(String name) {
            this.name = name;
        }

        String name;
        Long birthday;

        public Long getBirthday() {
            return birthday;
        }

        public String getName() {
            return name;
        }

        public static int compareByAge(Person a, Person b) {
            return a.birthday.compareTo(b.birthday);
        }

    }

    public int compareByName(Person a, Person b) {
        return a.getName().compareTo(b.getName());
    }

    public int compareByAge(Person a, Person b) {
        return a.getBirthday().compareTo(b.getBirthday());
    }

    public interface GetType<T> {
        T get(String value);
    }

    public Person getPerson(String name, GetType<Person> data) {
        return data.get(name);
    }
}
